package utils

import (
	"fmt"
	"strconv"
	"strings"
	"unicode"
)

// DataFormat 数据格式转换工具
type DataFormat struct{}

// ASCII2Hex 将ASCII文本转换为十六进制格式
// 支持两种格式：
// 1. 普通文本 -> "48 65 6C 6C 6F"
// 2. 包含[XX XX XX]格式的混合文本
func (df *DataFormat) ASCII2Hex(input string) (string, error) {
	var result strings.Builder
	var hexBytes []byte

	inBrackets := false
	var bracketContent strings.Builder

	for _, char := range input {
		if char == '[' {
			if inBrackets {
				return "", fmt.Errorf("嵌套的方括号不被支持")
			}
			inBrackets = true
			bracketContent.Reset()
		} else if char == ']' {
			if !inBrackets {
				return "", fmt.Errorf("未匹配的方括号")
			}
			inBrackets = false

			// 解析方括号内的十六进制数据
			hexStr := strings.TrimSpace(bracketContent.String())
			if hexStr != "" {
				hexData, err := df.Hex2Bin(hexStr)
				if err != nil {
					return "", fmt.Errorf("方括号内的十六进制格式错误: %v", err)
				}
				hexBytes = append(hexBytes, hexData...)
			}
		} else if inBrackets {
			bracketContent.WriteRune(char)
		} else {
			// 普通字符转换为字节
			hexBytes = append(hexBytes, byte(char))
		}
	}

	if inBrackets {
		return "", fmt.Errorf("未闭合的方括号")
	}

	// 转换为十六进制字符串
	for i, b := range hexBytes {
		if i > 0 {
			result.WriteString(" ")
		}
		result.WriteString(fmt.Sprintf("%02X", b))
	}

	return result.String(), nil
}

// Hex2ASCII 将十六进制格式转换为ASCII文本
// 输入格式：XX XX XX 或 XXXXXX
func (df *DataFormat) Hex2ASCII(input string) (string, error) {
	// 清理输入字符串
	cleaned := strings.ToUpper(strings.ReplaceAll(input, " ", ""))

	if len(cleaned)%2 != 0 {
		return "", fmt.Errorf("十六进制字符串长度必须是偶数")
	}

	var result strings.Builder

	for i := 0; i < len(cleaned); i += 2 {
		hexByte := cleaned[i : i+2]

		// 验证是否为有效的十六进制字符
		for _, char := range hexByte {
			if !((char >= '0' && char <= '9') || (char >= 'A' && char <= 'F')) {
				return "", fmt.Errorf("无效的十六进制字符: %c", char)
			}
		}

		// 转换为字节
		b, err := strconv.ParseUint(hexByte, 16, 8)
		if err != nil {
			return "", fmt.Errorf("十六进制解析失败: %v", err)
		}

		// 转换为可打印字符
		char := byte(b)
		if char >= 32 && char <= 126 {
			result.WriteByte(char)
		} else {
			result.WriteRune('.')
		}
	}

	return result.String(), nil
}

// Hex2Bin 将十六进制字符串转换为二进制数据
func (df *DataFormat) Hex2Bin(input string) ([]byte, error) {
	// 清理输入字符串
	cleaned := strings.ToUpper(strings.ReplaceAll(input, " ", ""))

	if len(cleaned)%2 != 0 {
		return nil, fmt.Errorf("十六进制字符串长度必须是偶数")
	}

	var result []byte

	for i := 0; i < len(cleaned); i += 2 {
		hexByte := cleaned[i : i+2]

		// 验证是否为有效的十六进制字符
		for _, char := range hexByte {
			if !((char >= '0' && char <= '9') || (char >= 'A' && char <= 'F')) {
				return nil, fmt.Errorf("无效的十六进制字符: %c", char)
			}
		}

		// 转换为字节
		b, err := strconv.ParseUint(hexByte, 16, 8)
		if err != nil {
			return nil, fmt.Errorf("十六进制解析失败: %v", err)
		}

		result = append(result, byte(b))
	}

	return result, nil
}

// Bin2Hex 将二进制数据转换为十六进制字符串
func (df *DataFormat) Bin2Hex(data []byte) string {
	var result strings.Builder

	for i, b := range data {
		if i > 0 {
			result.WriteString(" ")
		}
		result.WriteString(fmt.Sprintf("%02X", b))
	}

	return result.String()
}

// Bin2ASCII 将二进制数据转换为ASCII显示
func (df *DataFormat) Bin2ASCII(data []byte) string {
	var result strings.Builder

	for _, b := range data {
		if b >= 32 && b <= 126 {
			result.WriteByte(b)
		} else {
			result.WriteRune('.')
		}
	}

	return result.String()
}

// FormatHexDisplay 格式化十六进制显示，包装在方括号内
func (df *DataFormat) FormatHexDisplay(data []byte) string {
	if len(data) == 0 {
		return ""
	}

	var result strings.Builder
	result.WriteString("[")

	for i, b := range data {
		if i > 0 {
			result.WriteString(" ")
		}
		result.WriteString(fmt.Sprintf("%02X", b))
	}

	result.WriteString("]")
	return result.String()
}

// ParseMixedInput 解析混合格式输入（ASCII + [HEX]）
func (df *DataFormat) ParseMixedInput(input string) ([]byte, error) {
	var result []byte

	inBrackets := false
	var bracketContent strings.Builder

	for _, char := range input {
		if char == '[' {
			if inBrackets {
				return nil, fmt.Errorf("嵌套的方括号不被支持")
			}
			inBrackets = true
			bracketContent.Reset()
		} else if char == ']' {
			if !inBrackets {
				return nil, fmt.Errorf("未匹配的方括号")
			}
			inBrackets = false

			// 解析方括号内的十六进制数据
			hexStr := strings.TrimSpace(bracketContent.String())
			if hexStr != "" {
				hexData, err := df.Hex2Bin(hexStr)
				if err != nil {
					return nil, fmt.Errorf("方括号内的十六进制格式错误: %v", err)
				}
				result = append(result, hexData...)
			}
		} else if inBrackets {
			bracketContent.WriteRune(char)
		} else {
			// 普通字符转换为字节
			result = append(result, byte(char))
		}
	}

	if inBrackets {
		return nil, fmt.Errorf("未闭合的方括号")
	}

	return result, nil
}

// ValidateHexString 验证十六进制字符串格式
func (df *DataFormat) ValidateHexString(input string) error {
	cleaned := strings.ToUpper(strings.ReplaceAll(input, " ", ""))

	if len(cleaned)%2 != 0 {
		return fmt.Errorf("十六进制字符串长度必须是偶数")
	}

	for i, char := range cleaned {
		if !((char >= '0' && char <= '9') || (char >= 'A' && char <= 'F')) {
			return fmt.Errorf("位置 %d 处的字符 '%c' 不是有效的十六进制字符", i, char)
		}
	}

	return nil
}

// IsASCII 检查字符串是否为纯ASCII
func (df *DataFormat) IsASCII(s string) bool {
	for _, char := range s {
		if char > unicode.MaxASCII {
			return false
		}
	}
	return true
}

// GetDataFormatInstance 获取数据格式转换实例
func GetDataFormatInstance() *DataFormat {
	return &DataFormat{}
}
